Informationen zum MAX1000_K1 Projekt:
Autor: Klaus Kohl-Schöpe
Datum: 11.05.2020 Start des Projektes

Dies ist ein 16-Bit FORTH Prozessor basierend auf J1.
Folgende Änderungen wurden realisiert:
 - Speicher ist als Byte-Adressierbares 16-Bit RAM ausgelegt
 - PC kann nur gerade Adressen (16-Bit) adressieren - Bit 0 genutzt für Carry
 - Calls sind absolut und übernehmen auch Carry
 - Sprünge sind relativ und deshalb nur innerhalb ±2K erlaubt
 - Es gibt sowohl Programm- als auch IO-Bereich
 - Geänderter Befehlssatz:

// =============================================================
// K1 Opcode:
//
// 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0 = Opcode (16 Bit aligned)
// Literal:
//  0  x  x  x  x  x  x  x  x  x  x  x  x  x  x  x = Lit (bit 14 = bit 15 => -16384 ... +16383)
// Branches:
//  1  0  x  x  x  x  x  x  x  x  x  x  x  x  x  x = CALL (absolut: x * 2)
//  |  1  0  0  x  x  x  x  x  x  x  x  x  x  x  x = BRANCH (relativ: ±x * 2)
//  |  |  |  1  x  x  x  x  x  x  x  x  x  x  x  x = 0BRANCH (relativ: ±x * 2)
//  |  |  1  0  x  x  x  x  x  x  x  x  x  x  x  x = NEXT (relativ: ±x * 2 if R != 0 else RDROP)
// Memory and Alu:
//  1  1  1  1  0  ;  >R >N -- ALU  --  BW @! s  s = Memory Read/Write (@!=1: Write)
//  1  1  1  1  1  ;  >R >N -- ALU  --  r  r  s  s = Alu
//  ; and >R:      0  0 = R unchanged
//                 0  1 = T -> R
//                 1  0 = R -> PC (Exit)
//      - Memory:  1  1 = Execute (PC+2 -> R; T -> PC)
//      - ALU:     1  1                 0  0 = Goto (T -> PC)
//                 1  1                 0  1 = Execute (PC+2 -> R; T -> PC)
//                 1  1                 1  1 = RDROP, GOTO 
//                 1  1                 1  1 = RDROP, Execute 
//  >N:                  0 = N unchanged
//                       1 = T -> N
//  BW:                                 0 = Byte (TOS[0])
//                                      1 = Wort
//  @!:                                    0 = Lesen
//                                         1 = Schreiben
//  addition:                           1  1       = exit if rr = %11
//                                      0  1       = T > R if rr = %01
//  ALU (4-Bit):            0  0  0  0  |  |  |  | = T        (special: R)
//                          |  |  |  1  |  |  |  | = N        (special: RA = R with bit 0=0)
//                          |  |  1  0  |  |  |  | = +        (special: T+1)
//                          |  |  |  1  |  |  |  | = -        (special: T-1)
//                          |  1  0  0  |  |  |  | = AND      (special: T+2)
//                          |  |  |  1  |  |  |  | = OR       (special: T-2)
//                          |  |  1  0  |  |  |  | = XOR      (special: Carry - 0 or 1)
//                          |  |  |  1  |  |  |  | = INVERT   (special: INV14 = T xor $4000)
//                          1  0  0  0  |  |  |  | = ASHIFT   (nos >> tos[3:0] => tos or special: tos >> 1 - signed)
//                          |  |  |  1  |  |  |  | = RSHIFT   (nos >> tos[3:0] => tos or special: tos >> 1 - unsigned)
//                          |  |  1  0  |  |  |  | = LSHIFT   (nos << tos[3:0] => tos or special: tos << 1)
//                          |  |  |  1  |  |  |  | = 0=       (special: 0<)
//                          |  1  0  0  |  |  |  | = U<       (< unsigned or special: dsp)
//                          |  |  |  1  |  |  |  | = <        (< signed   or special: rsp)
//                          |  |  1  0  |  |  |  | = Divstep  (if T<R then T:N << 1 + 0 else (T-R:N) << 1 + 1 - not for memory - or special: SP!) 
//                          |  |  |  1  |  |  |  | = *        (special: UM* = T * N => T:N )
//  Stacks:                             r  r  |  | = Returnstack-Changes (-1 .. +1)
//                                      |  |  s  s = Datenstack-Changes (-1 .. +1; -2 is special)
//                                      Special: no stack changes if >N: not used
//
// During read from memory ALU use data instead of T
// If ss == 2'b10 (-2) then special function is selected - push T if >N (insn[9])
// Carry flag is modified by +, -, and shift operation
// =============================================================
// Usage of I/O Register:
//  $FF00 : uart_baud  (100MHz/Baudrate - 868 für 115200 Baud)
//  $FF02 : uart_state (Bit 0=TX full; Bit 1=RX full; Bit 2-7=BDBUS[5:0])
//                     (for write: Bit 7=DTR; Bit 4=RTS)
//  $FF04 : uart_data
//  $FF06 : leds       (Bit 0..7) - USER_BTN on Bit 8 (1=pressed))
//  $FF08 : counter_lo (12MHz)
//  $FF0A : counter_hi (12MHz/65536 - not latched)
//  $FF0C : PMOD data (Bit 0..7)
//  $FF0E : PMOD direction (Bit 0..7: 0=Input; 1=Output)
//  $FF10 : acc_baud  (100MHz/Baudrate/2 - 50 für 1MBaud)
//  $FF12 : Accelerometer (Bit 0..7: Data; 8=CS; 9=INT1, 10=INT2; 15=Busy)
// =============================================================
// Most used FORTH commands
//  $0000 ... $7ffe Literal (Bit 15 = Bit 14)
//  $8xxx ... $bxxx CALL (Bit 13:0 * 2)
//  $cxxx           BRANCH (ELSE und REPEAT - PC±xxx*2)
//  $dxxx           0BRANCH (IF und UNTIL - PC±xxx*2)
//  $exxx           NBRANCH (FOR - PC±xxx*2)
// -------------------------------------------------------------
//  $F000 ... $F8FF      Memory
//   $f000          C@
//   $f007          TUCK_C!
//   $f008          @
//   $f00F          TUCK_!
// -------------------------------------------------------------
//  $F800 ... $F8FF      ALU
//   $f800          NOP
//   $f8e2          SP! (Bit 15=DSTACK - Bit 14=RSTACK)
//   $f9c2          DEPTH
//   $f813          DROP
//   $f803          NIP
//   $f901          DUP
//   $f911          OVER
//   $f910          SWAP
//   $f9d2          RDEPTH
//   $fa17          >R
//   $f94e          R>
//   $f91e          RA>
//   $f902          R@
//   $f80c          RDROP
//   $fc0c          EXIT
//   $fe13          GOTO
//   $fe17          EXECUTE
//   $f843          AND
//   $f853          OR
//   $f863          XOR
//   $f870          INVERT
//   $f872          INV14
//   $f962          CARRY
//   $f823          +
//   $f833          -
//   $f822          1+
//   $f832          1-
//   $f842          2+
//   $f852          2-
//   $f883          ASHIFT
//   $f882          2/
//   $f893          RSHIFT
//   $f892          U2/
//   $f8a3          LSHIFT
//   $f8a2          2*
//   $f8e0          Divstep
//   $f8f2          UM*
//   $f8f3          *
//   $f8b0          0=
//   $f8b2          0<
//   $f8c3          U<
//   $f8d3          <
// -------------------------------------------------------------
//   : key?  $ff02 @  2 and ;
//   : key   BEGIN key? UNTIL  $ff04 @ ;
//   : emit? $ff02 @  1 and ;
//   : emit  BEGIN emit? UNTIL $ff04 ! ;
//
// =============================================================
//
// Example 1: NEXT-Schleife
// : x1
//   3  4  +  x2
//   BEGIN AGAIN ;
// : x2
//   FOR r@ drop NEXT ;
//
// $0000 $0003 Lit 3
// $0002 $0004 Lit 4
// $0004 $F823 +
// $0006 $8005 CALL $000A
// $0008 $CFFF BRANCH $0008
// $000A $FA17 >R
// $000C $F9E1 R@
// $000E $F813 DROP
// $0010 $EFFD NEXT $000C
// $0012 $F40C EXIT
//
// =============================================================
//
// Example 2: UART-Ausgabe
// : noname
//   $30
//   BEGIN dup emit
//         BEGIN emit? UNTIL
//         1+  dup  led !
//   AGAIN ;
//
// $0000 $0030 Lit $30
// $0002 $F901 DUP
// $0004 $4002 Lit $4002
// $0006 $F8A0 ASL ($8004)
// $0008 $F303 !
// $000A $F813 (DROP)
// $000C $4001 Lit $4001
// $000E $F8A0 ASL ($8002)
// $0010 $F200 @
// $0012 $0001 1
// $0014 $F843 AND
// $0016 $DFFA 0BRANCH $000C
// $0018 $0001 1
// $001A $F823 +
// $001C $F901 DUP
// $001E $4003 Lit $4003
// $0020 $F8A0 ASL ($8006)
// $0022 $F303 !
// $0024 $F813 (DROP)
// $0026 $CFED BRANCH $0002
//
// =============================================================

Logbuch:
11.05.2020:
 + Neustart des Projekts mit Definition des Befehlssatzes
24.05.2020:
 + Befehlssatz nochmal vereinfacht
26.05.2020: Compiliert und Simulator startet
 + Noch verfeinert (Stack-Tiefe + ALU auch für Memory-Read)
04.06.2020: Alle Files gemäß neuen Coding-Style umgestellt - und nur noch 12MHz ohne PLL verwendet
 + Demo läuft
05.06.2020
 + Special Function jetzt bei Stackänderung -2 gewählt
 + Carry-Flag implementiert
 + Programm mit Simulator und MAX1000 läuft (noch nicht weiter getestet)
08.06.2020
 + Test mit TC16_K1 und ersten Testprogrammen
 + TOR korrigiert
12.06.2020
 + Fehler bei EXIT korrigiert
 + Anpassung des SMAF an K1 gestartet - dabei auch TC16_K1 angepasst
13.06.2020
 + SMAF soweit am laufen, dass erste Ausgaben kommen
14-16.06.2020
 + Korrekturen am Speicherinterface, dass jetzt läuft (Stringausgabe)
 + SMAF startet und gibt erste Debug-Informationen und Strings aus
18.06.2020
 + >R ; ist als Branch oder Execute realisiert (tos => PC, evtl. pc+2 => tor)
 + Literal jetzt als ±16k - mit special code inv14 wird bit 14 invertiert (also ±16k)
 + Spezial-Codes verschoben und ergänzt um SHIFT-Befehle
19.06.2020
 + Shift n und Shift 1 Befehle vertauscht (damit Stack-Korrektur möglich ist)
 + Testausgabe für Simulation eingebaut
22.06.2020
 + Auch Speicher lesen/schreiben sychron mit Prozessortakt - jetzt mit 100MHz
 + Befehle und Speicherzugriffe getestet und entsprechend korrigiert
 => Targetcompiler und gelistete Befehle funktionieren
26.06.2020
 + Ausgaben des SMAF_K1 funktioniert, dann vermutlich beim Lesen von UART Probleme
27.06.2020
 + Fehler bei RX korrigiert (BDBUS[0] jetzt als Eingang zu RXD)
 + SMAF startet, hat aber noch Probleme mit ersten Ausgabezeichen und Compilieren
 + Nach Korrektur hat er noch Probleme bei nicht gefundenen Befehlen (Abort ???)
28.06.2020
 + Korrekturen im K1: Calls setzt Carry-Flag in PC und TOR zurück
 + Korrekturen im SMAF: Call absolut und Opcodes ohne Änderungen übernehmen
 => SMAF läuft im Simulator und im MAX1000
29.06.2020
 + myUART verwendet nur noch 1 Stop-Bit beim Senden
 + SMAF: Neue Befehle, DO...LOOP entfernt, Create dazu
 + Counter jetzt 100MHz
30.06.2020
 + Carry wieder im alten Zustand - aber statt PC@ jetzt RA = R mit Bit 0=0
 + Carry wird nur bei ALU und MEM-Befehle geändert - und bei exit
02.07.2020
 + SPI-Master Treiber für Accelerometer integriert
 + Test im SMAF geht (show_xyz)
03.07.2020
 + Division-Step integriert ( TOS:NOS / TOR => Ergebnis: TOS; Rest: NOS)
 + Geschwindigkeit 48MHz
 + Bei Fehler weitere Zeichen (bis zu 100ms/Zeichen) ignorieren
05-07.07.2020
 + Befehlsreihenfolge umgestellt
 + Optimierung in K1.v um große Demultiplexer zu vermeiden
 + Stackpointer auf 8 Bit erweitert, aber Stacks weiterhin auf 32 Einträge lassen
17.07.2020
 + SP! als zusätzlichen Befehl - Stack auf je 256 Einträge erweitert
 + Viele Korrekturen in SmallForth
13.08.2020
 + Zugriff auf UFM-Flash integriert
 + SmallForth erweitert, damit beim Start automatisch UFM ins RAM geladen wird
 + Bei gedrückten Button wird weiterhin das Orginal-Image verwendet

// =============================================================
// Nächste Schritte:
// =============================================================
 * Evtl. Fileinterface
 * Weitere Ports
 * SPI-Schnittstelle unterstützen
 * A/D-Wandler einbinden
 * Display realisieren

// =============================================================
// Umstellung auf Avalon-Bus für externen Speicher
// =============================================================

// =============================================================
// Beispielprogramme
// =============================================================
 * Ansteuerung von RGB-Leds
